/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 高生平
 * Date: 2025-08-27
 * Time: 13:00
 */
public class Demo {
    public static void main(String[] args) {
        //1.字面常量
        System.out.println("hello,world!");//字符串常量
        System.out.println(100);//整型常量
        System.out.println(3.14);//浮点数常量
        System.out.println('A');//字符常量
        System.out.println(true);//布尔常量
        System.out.println(false);//布尔常量

        //2.语法格式: 数据类型 变量名 = 初始值;
        int a = 10;
        double b = 3.14;
        char c = 'a';
        boolean d = true;

        System.out.println("==========");
        System.out.println(a);
        System.out.println(b);
        System.out.println(c);
        System.out.println(d);

        a = 100;//把100赋值给变量a
        System.out.println("==========");
        System.out.println(a);

        //一行可以定义多个相同类型的变量
        int a1 = 20, a2 = 30, a3 = 40;
        System.out.println("==========");
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);

        //3.整型变量
        System.out.println("==========");
        //方式一：在定义时给出初始值
        int x = 100;
        System.out.println(x);

        //方式二：在定义时没有给初始值，但是使用前必须设置初始值
        int y;
        y = 66;
        System.out.println(y);

        //使用方式二定义后，在使用前如果没有赋值，则编译期间会报错
//        int f;
//        System.out.println(f);
//        f = 5;

        System.out.println("==========");
        //int型变量所能表示的范围：
        System.out.println(Integer.MIN_VALUE);//int型的最小数
        System.out.println(Integer.MAX_VALUE);//int型的最大数
        //Integer时int的包装类型，通俗地讲就是int的plus版本

        //注意：在定义变量时，所赋值不能超过被赋值变量的范围
//        int n = 12345678901234;//编译时报错，因为初始值超过了int的范围

        int f1 = 10;
        long f2 = 10; //long定义的长整型变量

        long f3 = 10l;//为了区分int和long类型，一般建议：long类型类型变量的初始值之后加l或L
        long f4 = 10L;//一般加大写的L，因为小写l与1不好区分

        System.out.println("==========");
        //long型变量所能表示的范围：这个数据远超过int型的表示范围，足够绝大部分的工程场景使用
        System.out.println(Long.MIN_VALUE);//long型的最小数
        System.out.println(Long.MAX_VALUE);//long型的最大数
        //Long是long的包装类型

        //4.短整型变量
        System.out.println("==========");
        short k = 10;
        System.out.println(k);

        System.out.println("==========");
        //short型变量所能表示的范围：
        System.out.println(Short.MIN_VALUE);//short型的最小数
        System.out.println(Short.MAX_VALUE);//short型的最大数
        //Short是short的包装类型

        //5.字节型变量
        System.out.println("==========");
        byte s = 88;
        System.out.println(s);

        System.out.println("==========");
        //byte型变量所能表示的范围：
        System.out.println(Byte.MIN_VALUE);//byte型的最小数
        System.out.println(Byte.MAX_VALUE);//byte型的最大数
        //Byte是byte型的包装类型

        //6.浮点数变量
        //6.1 双精度浮点型
        System.out.println("==========");
        double kfc = 50;
        System.out.println(kfc);

        int g1 = 1;
        int g2 = 2;
        System.out.println(g1 / g2);//输出0
        //因为在Java中，int除以int的值仍然是int（会直接舍弃小数部分），
        //如果想要得到0.5，需要使用double类型进行计算

        double k1 = 1.0;
        double k2 = 2.0;
        System.out.println(k1 / k2);//输出0.5

        double p = 1.1;
        System.out.println(p);
        System.out.println(p * p);//输出1.2100000000000002
        //double类型的内存布局遵守IEEE 754标准（和C语言一样），尝试使用有限的内存空间表示可能无限的小数
        //势必会存在一定的误差，因此浮点数是个近似值，并不是精确值

        //6.2 单精度浮点型
        System.out.println("==========");
        float num = 1.0f;//也可以写作1.0F
        System.out.println(num);
        //由于float类型表示的数据精度范围较小，一般在工程上用到浮点数优先考虑double，不太推荐使用float

        //7.字符型常量
        System.out.println("==========");
        char c1 = 'a';//小写字母
        char c2 = 'A';//大写字母
        char c3 = '1';//数字字符
        System.out.println(c1);
        System.out.println(c2);
        System.out.println(c3);

        //注意；java中的字符可以存放整型，输出的是对应Unicode码表示的字符（相当于C语言中的ASCII）
        char c4 = 48;//创建一个名为 c4 的字符变量，并将十进制数字 48 所对应的字符赋值给它
        System.out.println(c4);//打印变量 c4 所代表的字符。Unicode码48对应的是字符‘0’，所以输出结果为字符0

        char c5 = '嗨';
        System.out.println(c5);

        //8.布尔型变量
        System.out.println("==========");
        boolean bool = true;
        System.out.println(bool);

        bool = false;
        System.out.println(bool);
        //与C语言不同，Java当中真假只有true和false，没有0和非0，也不能和任何类型转换，比如int b = bool

//        boolean value = true;
//        System.out.println(value + 1);//此代码就会出现编译错误

        //9.类型转换
        System.out.println("==========");
        int w = 10;
        long m = 100L;
        m = w;//可以通过编译
        System.out.println(m);
//        w = m;//编译失败
        System.out.println(w);

        //Java中类型转换只要分为两大类：自动类型转换（隐式）和强制类型转换（显式）
        //9.1 自动类型转换（隐式）：代码不需要经过任何处理，在代码编译时，编译器会自动进行处理
        //特点：数据范围小的转换为数据类型大的时会自动进行
        System.out.println("==========");
        System.out.println(1024);//整型默认情况下是int
        System.out.println(3.14);//浮点型默认情况下是double

        int ij = 100;
        long xy = 10L;
        xy = ij;//int类型的值自动转换为了long类型
        System.out.println(xy);//输出结果为100

        float ab =3.14F;
        double ac = 5.12;
        ac = ab;//float类型的值自动转换为了double类型
        System.out.println(ac);//输出结果为3.140000104904175

        //9.2 强制类型转换（显式）：当进行操作时，代码需要经过一定的格式处理，不能自动完成
        //特点：数据范围大的类型转换为数据范围小的类型
        System.out.println("==========");
        int i1 = 10;
        long i2 = 100L;
        i2 = i1; //int --> long,数据范围由小到大，隐式转换
        System.out.println(i2);
        i1 = (int)i2; //long --> int，数据范围由大到小，需要强制转换，否者编译失败
        System.out.println(i1);

        float fd1 = 3.14F;
        double fd2 = 5.12;
        fd2 = fd1;//float --> double，数据范围由小到大，隐式转换
        System.out.println(fd2);
        fd1 = (float)fd2;//double --> float,数据范围由大到小，需要强制转换，否者编译失败
        System.out.println(fd1);

        byte b1 = 100;//100默认为int，没有超过byte范围，隐式转换
        byte b2 = (byte)257;//257默认为int， 超过byte范围，需要显式转换，否者编译失败
        System.out.println(b1);
        System.out.println(b2);

        //10.类型提升：不同类型的数据之间相互计算时，数据类型小的会被提升到数据类型大的
        System.out.println("==========");
        int num1 = 10;
        long num2 = 20;
//        int num3 = num1 + num2;//编译出错，num1 + num2 --> int + long --> long + long 赋值给int时会丢失数据
        long num4 = num1 + num2;//编译成功，num1 + num2 --> int + long --> long + long 赋值给long
        System.out.println(num4);

        byte num11 = 10;
        byte num12 = 20;
//        byte num13 = num11 + num12;//编译出错，
//        原因是num11和num12虽然都是byte，但是计算num11+num12会将num11和num12都提升为int，
//        再进行计算，得到的结果也是int，这时赋给num13，就会出现编译错误
        //正确的写法：
        byte num13 = (byte)(num11 + num12);
        System.out.println(num13);

        //11.字符串类型
        System.out.println("==========");
        String s1 = "hello";
        String s2 = " world";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(s1 + s2);//s1 + s2表示：将s1和s2进行拼接

        //11.1 int转成String
        System.out.println("==========");
        int num21 = 10;
        //方法一
        String str1 = num21+ "";//这个加号就是拼接的意思
        System.out.println(str1);
        //方法二
        String str2 = String.valueOf(num21);//调用String这个类型的方法
        System.out.println(str2);

        System.out.println("==========");
        String str3 = 10 + 20 + "x";//结果为30x，先计算10+20的结果，为30，再用30拼接字符串x
        System.out.println(str3);

        String str4 = "x" + 10 + 20;//结果为x1020，“x”与10拼接变成字符串“x10”，字符串"x10"再与20拼接变成“x1020”
        System.out.println(str4);

        //11.2 String转成int
        System.out.println("==========");
        String str = "100";
        int num51 = Integer.parseInt(str);//调用Integer的方法来实现转换
        System.out.println(num51);
        int num52 = Integer.valueOf(str);
        System.out.println(num52);
    }
}
